Overloading המחלקה למדעי המחשב עזאם מרעי אוניברסיטת בן-גוריון

Transcription

1 Overloading עזאם מרעי המחלקה למדעי המחשב אוניברסיטת בן-גוריון

2 2 Roadmap In this chapter we will investigate the idea of overloading: Overloading based on scopes Overloading based on type signatures Coercion, Conversion and Casts Redefinition Polyadicity

3 3 A Definition of Overloading We say a term is overloaded if it has two or more meanings Most words in natural languages are overloaded, and confusion is resolved by means of context Lead Same is true of OO languages. There are two important classes of context that are used to resolve overloaded names Overloading based on Scopes Overloading based on Type Signatures

4 4 Overloading Based on Scopes A name scope defines the portion of a program in which a name can be used, or the way it can be used. Scopes are introduced using lots of different mechanisms: Classes or interfaces Packages or Units Procedures or Functions in some languages, even Blocks An advantage of scopes is that the same name can appear in two or more scopes with no ambiguity

5 5 Florist Example from Chapter 1 Procedure Friend.sendFlowersTo (anaddress : address); begin go to florist; give florist message sendflowersto(anaddress); end; Procedure Florist.sendFlowersTo (anaddress : address); begin if address is nearby then make up flower arrangement tell delivery person sendflowersto(anaddress); else look up florist near anaddress phone florist give florist message sendflowersto(anaddress) end; No inheritance involved! The first common superclass is the category Human Florist Human Friend

6 6 Resolving Overloaded Names This type of overloading is resolved by looking at the static type of the receiver Allows the same name to be used in unrelated classes There is nothing intrinsic to overloading that requires the functions associated with an overloaded name to have any semantic similarity The method draw was used to draw the image of a card on the screen and to draw a single card from the top of the deck. Not even remotely similar in semantics Is this a bad style? Since names need not be distinct, allows short, easy to remember, meaningful names

7 7 Overloading Based on Type Signatures A different type of overloading allows multiple implementations in the same scope to be resolved using type signatures class Example { // same name, three different methods int sum (int a) { return a; } int sum (int a, int b) { return a + b; } int sum (int a, int b, int c) { return a + b + c; } } A type signature of method is: argument types, their order, the return type: power: double x int double By looking at the signature of a call, the compiler can tell, at compile time, which version is intended Methods cannot be overloaded based on differences in their return types

8 8 Resolution Performed at Compile Time (1) Note that resolution is performed at compile time, based on static types, and not dynamic values. class Parent {... }; class Child : public Parent {... }; void test(parent * p) { cout << "in parent" << endl; } void test(child * c) { cout << "in child" << endl } Parent * value = new Child(); test(value); in parent Example will, perhaps surprisingly, execute Parent function

9 9 Resolution Performed at Compile Time (2) Note that resolution is performed at compile time, based on static types, and not dynamic values. class Parent{ public: void test(parent * p) {cout << "in parent" << endl;}}; Child: public Parent{ public: void test(child * c) {cout << "in child" << endl;}}; Parent * value = new Child(); value->test(value); in parent Example will, perhaps surprisingly, execute Parent function

10 10 Conversion and Coercion When one adds conversions into the mix, resolving overloaded function or method calls can get very complex. Many different types of conversions: Implicit value changing conversion (such as real to integer) Implicit conversion that does not change value (pointer to child class converted into pointer to parent) Cat c = new Cat )( ; Mammal m = c; // upcasting c.eat(); Explicit conversions (casts)

11 11 Conversion and Coercion Used when actual arguments of a method do not match the formal parameter specifications, but can be converted into a form that will match Coercion - implicitly implemented Conversion explicitly requested by the programmer Casting

12 Substitution as Conversion If two or more methods have the same name and number of parameters, the compiler uses algorithm to determine match 1. find all methods that could possible apply to the method call and if one matches argument types exactly, use that one. 2. if a method s parameter types are all assignments to any other method in the set, then eliminate the second method 3. If exactly one method remains, use it, else give compiler error

13 13 Example 1.void order (Dessert d, Cake c); 2.void order (Pie p, Dessert d); 3.void order (ApplePie a, Cake c); order (adessert, acake); 1 order (anapplepie, adessert); 2 order (adessert, adessert); // illegal order (anapplepie, achocolatecake); all three methods, then method 3 order (apie, acake); // illegal

14 14 Examples Class A: public int foo(int x, double y){ System.out.println("int*double->int"); System.out.println(x); return x; } public double foo(double x, int y){ System.out.println("double*int->double"); System.out.println(x); return x; } A a = new A(); a.foo(1.5,2); double*int->double 1.5 a.foo(1,2.5); int*double->int 1 a.foo(1,2);

15 15 Class B extends A: Examples public double foo(int x, int y){ System.out.println("int*int->double"); System.out.println(x); return x; } A a = new B();

16 16 Redefinitions A redefinition occurs when a child class changes the type signature of a method in the parent class. Two different types of rules are used to resolve names: The merge model (Java) The scope of the child is merged with the scope of the parent The hierarchical model (C++) Scopes are separate. Search is made for first scope containing name, then for best fit within the scope.

17 17 Example Illustrating Redefinition Models The following example will illustrate the difference in these two models: class Parent { public void example (int a) { System.out.println("in parent method"); } } class Child extends Parent { public void example (int a, int b) { System.out.println("in child method"); } } Child achild = new Child(); achild.example(3); Will execute parent method in Java and C# (merge model) and give error in C++ (hierarchical model). Delphi allows programmer control over this.

18 18 Example Illustrating Redefinition Models The following example will illustrate the difference in these two models: class Parent{ public: void example (int a){ cout << "in parent" << endl;} }; class Child: public Parent{ public: void example (int a, int b) { cout << "in child" << endl; } }; Child * achild = new Child(); achild->example(1); error: no matching function for call to 'Child::example(int)' achild->example(1);

19 19 Example Illustrating Redefinition Models The following example will illustrate the difference in these two models: class Parent{ public: void example (int a){ cout << "in parent" << endl;} }; class Child: public Parent{}; Child * achild = new Child(); achild->example(1); in parent

20 20 Optional Parameters Some languages allow the programmer to create optional parameters, usually only at the end of the parameter list: function Count (A, B : Integer; C : Integer = 0; D : Integer = 0); begin (* Result is a pseudo-variable used *) (* to represent result of any function *) Result := A + B + C + D; end begin Writeln (Count(2, 3, 4, 5)); // can use four arguments Writeln (Count(2, 3, 4)); // or three Writeln (Count(2, 3)); // or two end Such a function will have more than one type signature

21 Optional Parameters Scheme Version 1 Version 2 (define print-all (lambda things (for-each (lambda (x) (display x) (newline)) things))) > (print-all 1 2) 1 2 > (print-all 1 2 3) > (print-all) > (define printoneatleast (lambda(a. things) (display a) (newline) (for-each (lambda (x) (display x) (newline)) things))) > (printoneatleast 1 2 3) > (printoneatleast) #<procedure>: expects at least 1 argument, given 0 > 21

22 22 Arbitrary Number of Arguments in C# The language C# has an interesting way to include arbitrary number of arguments: class ParamsExample { public void Write (int x) { // use this with one argument WriteString("Example one "); WriteString(x.ToString()); } public void Write (double x, int y) { // use this with two arguments WriteString("Example two "); WriteString(x.ToString()); WriteString(y.ToString()); } } public void Write (params object [ ] args) { // use this with any other combination WriteString("Example three "); for (int i = 0; i < args.getlength(0); i++) WriteString(args[i].ToString()); } Such a function will infinitely many type signatures

23 23 Chapter Summary In this chapter we have looked at various aspects of overloading Overloading based on scopes Overloading based on type signatures Redefinition Polyadicity (functions with variable number of arguments)